#include "colorplot.h"
#include <qdebug.h>

const QColor defaultBackgroundGray = QColor(180,180,180);
const QColor defaultBackgroundDark = QColor(6,1,36);
const QColor defaultBackgroundLight = QColor(242,241,233);

const QColor defaultCurveGray = QColor(253,255,153);
const QColor defaultCurveDark = QColor(200,190,210);
const QColor defaultCurveLight = QColor(50,0,50);

ColorPlot::ColorPlot(const QColor firstColor)
{
    setBaseColors(firstColor);
    setComplColors(firstColor);
    int h, s, v;
    firstColor.getHsv(&h, &s, &v);
    setBackgroundColor(s,v);
    qDebug()<<"HSV " << h << s << v;

}
ColorPlot::~ColorPlot()
{
}

void ColorPlot::setBaseColors(QColor color)
{
    qDebug()<<"-1) ColorPlot::setBaseColors()"<< color;
    int h = 0 ,s = 0,v = 0;
    color.getHsv(&h, &s, &v);
    // теперь в переменных hsv хранятся значения hsv первого цвета
    for(int i = 0; i < 4; i++)
    {
        int newH = 0, newS = 0, newV = 0;
        newH = h + (i * 90);
        newS = s;
        newV = v;
        QColor newColor;
        newColor.setHsv(newH, newS, newV);
        newColor.toRgb();
        d_baseColors[i] = newColor;

        qDebug()<<i<<") ColorPlot::setBaseColors()"<<d_baseColors[i];
    }

}

QColor ColorPlot::getCurveColor(int index)
{
    if (index%2==1)
    {
        qDebug()<<"colorplot: color"<< index << d_complColors[(index-1)/2];
        return d_complColors[(index-1)/2];
    }
    else
    {
        qDebug()<<"colorplot: color"<<  index <<d_baseColors[index/2];
        return d_baseColors[index/2];
    }
}

void ColorPlot::setComplColors(QColor color)
{
    int h = 0, s = 0, v = 0;
    color.getHsv(&h, &s, &v);
    //если цвет тёмный то комплиментарный цвет назначается более светлый
    if ( v < 128){
        color.setHsv(h, s, 170);
        color.getHsv(&h, &s, &v);
    }
    //если светлый - то комплиментарный цвет будет темнее основного
    else
    {
        color.setHsv(h, s, 70);
        color.getHsv(&h, &s, &v);
    }
    for (int i = 0; i < 4; i ++ )
    {
        searchSaturation(s);
        int newH = 0, newS = 0, newV = 0;
        newH = h  + (i * 90);
        newS = s_complColor;
        newV = v;
        QColor newColor;
        newColor.setHsv(newH, newS, newV);
        newColor.toRgb();
        d_complColors[i] = newColor;
                qDebug()<<i<<") ColorPlot::setComplColors()"<<d_complColors[i];
    }
}

void ColorPlot::print(int index)
{
    QColor aaa = getCurveColor(index);
    int r, g, b;
    aaa.getRgb(&r ,&g ,&b);
    int h, s, v;
    aaa.getHsv(&h, &s, &v);
    qDebug()<<"Color for curve "<<index<<"RGB"<< r << g << b<<"HSV"<< h << s << v;
}

void ColorPlot::setBackgroundColor(int saturation, int value)
{

    if(saturation < 0 || saturation > 255)
    {
        d_backgroundColor = defaultBackgroundGray;
        d_gridColor = d_backgroundColor.lighter(300);
        return;
    }
    if(saturation < 81)
    {
        d_backgroundColor = defaultBackgroundDark;
        d_gridColor = d_backgroundColor.lighter(500);
        return;
    }
    else {
        if ( saturation > 162)
        {
            d_backgroundColor = defaultBackgroundLight;
            d_gridColor = d_backgroundColor.darker(300);
            return;
        }
        else {
            d_backgroundColor = defaultBackgroundGray;
            d_gridColor = d_backgroundColor.darker(300);
            return;
        }
    }
    return;
}

void ColorPlot::setBackgroundColor(const QColor a)
{
    d_backgroundColor = a;
}

void ColorPlot::setCurveColor(const QColor color, const int index)
{
    if (index%2==1)
    {
        d_baseColors[(index-1)/2] = color;
    }
    else
        d_complColors[(index)/2] = color;
}

QColor ColorPlot::getBackgroundColor() const
{
    return d_backgroundColor;
}

QColor ColorPlot::getGridColor() const
{
    return d_gridColor;
}

void ColorPlot::searchSaturation(int s)
{
    if ( s < Saturation::s_white || s > Saturation::s_black )
    {
        return;
    }
    if ( s < Saturation::s_light )
    {
        s_complColor = s + stepCurve;
        return;
    }
    else
    {
        if ( s > Saturation::s_dark)
        {
            s_complColor = s - stepCurve;
            return;
        }
        else
        {
            s_complColor = s - stepCurve;
            return;
        }
    }
}

